home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Pascal / Applications / NIH Image 1.62b11 / src / Init.p < prev    next >
Text File  |  1997-02-14  |  56KB  |  2,043 lines

  1. unit Init;
  2.  
  3. interface
  4.  
  5.  
  6.     uses
  7.         Types, Memory, QuickDraw, QuickDrawText, Packages, Menus, Events, Fonts, 
  8.         Scrap, ToolUtils, Resources, Errors, Palettes, StandardFile, Windows,
  9.         Controls, TextEdit, Files, Dialogs, TextUtils, Finder, MixedMode, SegLoad,
  10.         Folders, Slots, OSUtils, Strings, GestaltEqu, Processes,
  11.         globals, Utilities, Graphics, Lut;
  12.  
  13.     procedure Init;
  14.     procedure AllocateBuffers;
  15.     procedure AllocateArrays;
  16.     procedure SetupMenus;
  17.     procedure GetPreferences(f: integer);
  18.     procedure GetSettings;
  19.     procedure FindPlugIns;
  20.     
  21.     {To compile NIH Image so that it supports Scion PCI frame grabbers you
  22.     will need to set 'SupportScionPCI' to 1 and add the following libraries
  23.     in the NIH Image project:
  24.     
  25.                     ScionPCI.lib
  26.                     PCILib
  27.                     NameRegistryLib
  28.                     DriverServicesLib
  29.     
  30.     ScionPCI.lib is included with the NIH Image source. The other libraries
  31.     are on Apple's Developer CD.}
  32.     
  33.     {$SETC SupportScionPCI := 1}
  34.  
  35.     {$ifc PowerPC and SupportScionPCI}
  36.     function LookForPCIFrameGrabbers(model: integer; var base0: longint; var base1: longint; var buffers: longint): boolean; C; EXTERNAL;
  37.     {$endc}
  38.  
  39.  
  40. implementation
  41.  
  42.  
  43.     procedure MakeCursors;
  44.         var
  45.             TempCurH: CursHandle;
  46.             i, id: integer;
  47.     begin
  48.         TempCurH := GetCursor(PickerCursorID);
  49.         if TempCurH <> nil then
  50.             begin
  51.                 PickerCursor := TempCurH^^;
  52.                 ToolCursor[PickerTool] := PickerCursor;
  53.                 ReleaseResource(handle(TempCurH));
  54.             end;
  55.  
  56.         TempCurH := GetCursor(CrossCursorPlusID);
  57.         if TempCurH <> nil then
  58.             begin
  59.                 CrossPlusCursor := TempCurH^^;
  60.                 ReleaseResource(handle(TempCurH));
  61.             end;
  62.  
  63.         TempCurH := GetCursor(CrossCursorMinusID);
  64.         if TempCurH <> nil then
  65.             begin
  66.                 CrossMinusCursor := TempCurH^^;
  67.                 ReleaseResource(handle(TempCurH));
  68.             end;
  69.  
  70.         TempCurH := GetCursor(WandPlusCursorID);
  71.         if TempCurH <> nil then
  72.             begin
  73.                 WandPlusCursor := TempCurH^^;
  74.                 ReleaseResource(handle(TempCurH));
  75.             end;
  76.  
  77.         TempCurH := GetCursor(WandMinusCursorID);
  78.         if TempCurH <> nil then
  79.             begin
  80.                 WandMinusCursor := TempCurH^^;
  81.                 ReleaseResource(handle(TempCurH));
  82.             end;
  83.  
  84.         TempCurH := GetCursor(CrossCursorID);
  85.         if TempCurH <> nil then
  86.             begin
  87.                 ToolCursor[SelectionTool] := TempCurH^^;
  88.                 ToolCursor[FreehandTool] := TempCurH^^;
  89.                 ToolCursor[PolygonTool] := TempCurH^^;
  90.                 ToolCursor[ruler] := TempCurH^^;
  91.                 ToolCursor[PlotTool] := TempCurH^^;
  92.                 ToolCursor[OvalSelectionTool] := TempCurH^^;
  93.                 ToolCursor[LineTool] := TempCurH^^;
  94.                 ToolCursor[AngleTool] := TempCurH^^;
  95.                 ToolCursor[CrossHairTool] := TempCurH^^;
  96.                 ToolCursor[LUTTool] := TempCurH^^;
  97.                 ReleaseResource(handle(TempCurH));
  98.             end;
  99.  
  100.         TempCurH := GetCursor(LUTCursorID);
  101.         if TempCurH <> nil then
  102.             begin
  103.                 LUTCursor := TempCurH^^;
  104.                 ReleaseResource(handle(TempCurH));
  105.             end;
  106.  
  107.         TempCurH := GetCursor(gmCursorID);
  108.         if TempCurH <> nil then
  109.             begin
  110.                 gmCursor := TempCurH^^;
  111.                 ReleaseResource(handle(TempCurH));
  112.             end;
  113.  
  114.         TempCurH := GetCursor(GrabberCursorID);
  115.         if TempCurH <> nil then
  116.             begin
  117.                 ToolCursor[Grabber] := TempCurH^^;
  118.                 ReleaseResource(handle(TempCurH));
  119.             end;
  120.  
  121.         TempCurH := GetCursor(PencilCursorID);
  122.         if TempCurH <> nil then
  123.             begin
  124.                 ToolCursor[Pencil] := TempCurH^^;
  125.                 ReleaseResource(handle(TempCurH));
  126.             end;
  127.  
  128.         TempCurH := GetCursor(GlassCursorPlusID);
  129.         if TempCurH <> nil then
  130.             begin
  131.                 ToolCursor[MagnifyingGlass] := TempCurH^^;
  132.                 ReleaseResource(handle(TempCurH));
  133.             end;
  134.  
  135.         TempCurH := GetCursor(GlassCursorMinusID);
  136.         if TempCurH <> nil then
  137.             begin
  138.                 GlassMinusCursor := TempCurH^^;
  139.                 ReleaseResource(handle(TempCurH));
  140.             end;
  141.  
  142.         TempCurH := GetCursor(BucketCursorID);
  143.         if TempCurH <> nil then
  144.             begin
  145.                 ToolCursor[PaintBucket] := TempCurH^^;
  146.                 ReleaseResource(handle(TempCurH));
  147.             end;
  148.  
  149.         TempCurH := GetCursor(WandCursorID);
  150.         if TempCurH <> nil then
  151.             begin
  152.                 ToolCursor[Wand] := TempCurH^^;
  153.                 ReleaseResource(handle(TempCurH));
  154.             end;
  155.  
  156.         TempCurH := GetCursor(TextCursorID);
  157.         if TempCurH <> nil then
  158.             begin
  159.                 ToolCursor[TextTool] := TempCurH^^;
  160.                 ReleaseResource(handle(TempCurH));
  161.             end;
  162.  
  163.         TempCurH := GetCursor(EraserCursorID);
  164.         if TempCurH <> nil then
  165.             begin
  166.                 ToolCursor[eraser] := TempCurH^^;
  167.                 ReleaseResource(handle(TempCurH));
  168.             end;
  169.  
  170.         TempCurH := GetCursor(SprayCursorID);
  171.         if TempCurH <> nil then
  172.             begin
  173.                 ToolCursor[SprayCanTool] := TempCurH^^;
  174.                 ReleaseResource(handle(TempCurH));
  175.             end;
  176.  
  177.         TempCurH := GetCursor(BrushCursorID);
  178.         if TempCurH <> nil then
  179.             begin
  180.                 ToolCursor[brush] := TempCurH^^;
  181.                 ReleaseResource(handle(TempCurH));
  182.             end;
  183.  
  184.         TempCurH := GetCursor(WatchCursor);
  185.         if TempCurH <> nil then
  186.             begin
  187.                 watch := TempCurH^^;
  188.                 ReleaseResource(handle(TempCurH));
  189.             end;
  190.             
  191.         for i := 1 to 8 do
  192.             AnimatedWatch[i] := watch;
  193.         id := FirstAnimatedWatchID;
  194.         for i := 2 to 8 do
  195.             begin
  196.                 TempCurH := GetCursor(id);
  197.                 id := id + 1;
  198.                 if TempCurH <> nil then
  199.                     begin
  200.                         AnimatedWatch[i] := TempCurH^^;
  201.                         ReleaseResource(handle(TempCurH));
  202.                     end;
  203.             end;
  204.  
  205.         TempCurH := GetCursor(FingerCursorID);
  206.         if TempCurH <> nil then
  207.             begin
  208.                 FingerCursor := TempCurH^^;
  209.                 ReleaseResource(handle(TempCurH));
  210.             end;
  211.             
  212.     end;
  213.  
  214.  
  215.     procedure MakeToolsBitMap;
  216.   {Creates the offscreen bitmap used to draw the tool palette.}
  217.         var
  218.             tPort: GrafPtr;
  219.             TempPort: GrafPort;
  220.             PicH: PicHandle;
  221.             FrameRect: rect;
  222.             fwidth, fheight: integer;
  223.     begin
  224.         PicH := GetPicture(130);
  225.         if PicH = nil then
  226.             ExitToShell;
  227.         FrameRect := PicH^^.PicFrame;
  228.         with FrameRect do
  229.             begin
  230.                 fwidth := right - left;
  231.                 fheight := bottom - top;
  232.             end;
  233.         GetPort(tPort);
  234.         OpenPort(@TempPort);
  235.         with ToolBits, FrameRect do
  236.             begin
  237.                 baseAddr := NewPtr((fwidth * fheight) div 8);
  238.                 if baseAddr = nil then
  239.                     ExitToShell;
  240.                 rowBytes := fwidth div 8;
  241.                 SetRect(bounds, 0, 0, fwidth, fheight);
  242.             end;
  243.         SetPortBits(ToolBits);
  244.         DrawPicture(PicH, ToolBits.bounds);
  245.         ReleaseResource(handle(PicH));
  246.         ClosePort(@TempPort);
  247.         SetPort(tPort);
  248.     end;
  249.  
  250.  
  251.     procedure InitTools;
  252.         var
  253.             ToolTop, LinesTop, i: integer;
  254.             Tool: ToolType;
  255.     begin
  256.         MakeToolsBitmap;
  257.         FirstTool := MagnifyingGlass;
  258.         LastTool := CrossHairTool;
  259.         CurrentTool := SelectionTool;
  260.         isSelectionTool := true;
  261.         PreviousTool := CurrentTool;
  262.         ToolTop := 0;
  263.         for tool := FirstTool to LastTool do
  264.             with ToolRect[tool] do
  265.                 begin
  266.                     top := ToolTop;
  267.                     bottom := top + tmiddle;
  268.                     if odd(ord(tool) + 1) then
  269.                         left := 0
  270.                     else
  271.                         begin
  272.                             left := tmiddle;
  273.                             ToolTop := ToolTop + tmiddle;
  274.                         end;
  275.                     right := left + tmiddle;
  276.                 end;
  277.         ToolTime := 0;
  278.         LutTime := 0;
  279.         StartOfLines := ToolRect[LastTool].bottom - 1;
  280.         LinesTop := StartOfLines + 10;
  281.         for i := 1 to nLineTypes do
  282.             with lines[i] do
  283.                 begin
  284.                     left := LinesLeft;
  285.                     top := LinesTop;
  286.                     right := LinesRight;
  287.                     case i of
  288.                         1, 2, 3, 4: 
  289.                             bottom := top + i;
  290.                         5: 
  291.                             bottom := top + 6;
  292.                         6: 
  293.                             bottom := top + 8
  294.                     end;
  295.                     LinesTop := bottom + 4;
  296.                 end;
  297.         LineWidth := 1;
  298.         LineIndex := 1;
  299.         with CheckRect do
  300.             begin
  301.                 left := 0;
  302.                 top := StartOfLines;
  303.                 right := LinesLeft;
  304.                 bottom := theight;
  305.             end;
  306.     end;
  307.  
  308.  
  309.     procedure AllocateBuffers;
  310.         var
  311.             tPort: GrafPtr;
  312.             err: OSErr;
  313.             BufSizeStr: str255;
  314.             atemp: integer;
  315.             SaveGDevice: GDHandle;
  316.     begin
  317.         SaveGDevice := GetGDevice;
  318.         SetGDevice(osGDevice);
  319.         GetPort(tPort);
  320.         NumToString(BufferSize div 1024, BufSizeStr);
  321.         BigBufSize := BufferSize * 2;
  322.         if FreeMem > (BigBufSize + 300000) then
  323.             BigBuf := NewPtr(BigBufSize)
  324.         else
  325.             BigBuf := nil;
  326.         if BigBuf = nil then
  327.             BigBufSize := 0;
  328.         if BigBuf <> nil then
  329.             UndoBuf := BigBuf
  330.         else
  331.             begin
  332.                 if FreeMem > (BufferSize + 200000) then
  333.                     UndoBuf := NewPtr(BufferSize)
  334.                 else
  335.                     UndoBuf := nil;
  336.             end;
  337.         if UndoBuf <> nil then
  338.             UndoBufSize := BufferSize
  339.         else
  340.             begin
  341.                 PutError(concat('There is not enough memory available to allocate the ', BufSizeStr, 'K Undo buffer. Many operations may fail or may not be Undoable.'));
  342.                 UndoBufSize := 0;
  343.             end;
  344.         if BigBuf <> nil then
  345.             ClipBuf := ptr(ord4(BigBuf) + BufferSize)
  346.         else
  347.             begin
  348.                 if FreeMem > (BufferSize + 300000) then
  349.                     ClipBuf := NewPtr(BufferSize)
  350.                 else
  351.                     ClipBuf := nil;
  352.             end;
  353.         UndoInfoRec := NoInfo^;
  354.         UndoInfo := @UndoInfoRec;
  355.         if UndoBuf <> nil then
  356.             with UndoInfo^ do
  357.                 begin
  358.                     roiRgn := NewRgn;
  359.                     PicBaseAddr := UndoBuf;
  360.                     osPort := CGrafPtr(NewPtr(SizeOf(CGrafPort)));
  361.                     OpenCPort(osPort);
  362.                     osPort^.portPixMap^^.BaseAddr := PicBaseAddr;
  363.                     SetPalette(WindowPtr(osPort), ExplicitPalette, false);
  364.                 end;
  365.         if ClipBuf <> nil then
  366.             begin
  367.                 ClipBufSize := BufferSize;
  368.                 ClipBufInfoRec := NoInfo^;
  369.                 ClipBufInfo := @ClipBufInfoRec;
  370.                 with ClipBufInfo^ do
  371.                     begin
  372.                         roiRgn := NewRgn;
  373.                         PicBaseAddr := ClipBuf;
  374.                         osPort := CGrafPtr(NewPtr(SizeOf(CGrafPort)));
  375.                         OpenCPort(osPort);
  376.                         osPort^.portPixMap^^.BaseAddr := PicBaseAddr;
  377.                         BytesPerRow := 0;
  378.                         SetPalette(WindowPtr(osPort), ExplicitPalette, false);
  379.                     end;
  380.             end
  381.         else
  382.             begin
  383.                 PutError(concat('There is not enough memory available to allocate the ', BufSizeStr, 'K Clipboard Buffer. Many operations, including Copy and Paste, may fail.'));
  384.                 ClipBufSize := 0;
  385.             end;
  386.         SetPort(tPort);
  387.         SetGDevice(SaveGDevice);
  388.     end;
  389.  
  390.  
  391.     procedure AllocateArrays;
  392.         var
  393.             nItems: LongInt;
  394.             i: integer;
  395.  
  396.         procedure Abort;
  397.         begin
  398.             PutError('Not enough memory available to allocate arrays.');
  399.             ExitToShell;
  400.         end;
  401.  
  402.     begin
  403.         PlotData := rLinePtr(NewPtr(SizeOf(rLineType)));
  404.         if PlotData = nil then
  405.             abort;
  406.         nItems := maxCoordinates;
  407.         xCoordinates := xCoordinatesPtr(NewPtr(nItems * SizeOf(integer)));
  408.         if xCoordinates = nil then
  409.             abort;
  410.         yCoordinates := yCoordinatesPtr(NewPtr(nItems * SizeOf(integer)));
  411.         if yCoordinates = nil then
  412.             abort;
  413.         nItems := MaxMeasurements + 1;
  414.         mean := meanPtr(NewPtr(nItems * SizeOf(real)));
  415.         if mean = nil then
  416.             abort;
  417.         sd := sdPtr(NewPtr(nItems * SizeOf(real)));
  418.         if sd = nil then
  419.             abort;
  420.         PixelCount := PixelCountPtr(NewPtr(nItems * SizeOf(LongInt)));
  421.         if PixelCount = nil then
  422.             abort;
  423.         mArea := AreaPtr(NewPtr(nItems * SizeOf(real)));
  424.         if mArea = nil then
  425.             abort;
  426.         mode := modePtr(NewPtr(nItems * SizeOf(real)));
  427.         if mode = nil then
  428.             abort;
  429.         IntegratedDensity := IntegratedDensityPtr(NewPtr(nItems * SizeOf(real)));
  430.         if IntegratedDensity = nil then
  431.             abort;
  432.         idBackground := idBackgroundPtr(NewPtr(nItems * SizeOf(real)));
  433.         if idBackground = nil then
  434.             abort;
  435.         xcenter := xcenterPtr(NewPtr(nItems * SizeOf(real)));
  436.         if xcenter = nil then
  437.             abort;
  438.         ycenter := ycenterPtr(NewPtr(nItems * SizeOf(real)));
  439.         if ycenter = nil then
  440.             abort;
  441.         MajorAxis := MajorAxisPtr(NewPtr(nItems * SizeOf(real)));
  442.         if MajorAxis = nil then
  443.             abort;
  444.         MinorAxis := MinorAxisPtr(NewPtr(nItems * SizeOf(real)));
  445.         if MinorAxis = nil then
  446.             abort;
  447.         orientation := orientationPtr(NewPtr(nItems * SizeOf(real)));
  448.         if orientation = nil then
  449.             abort;
  450.         mMin := MinPtr(NewPtr(nItems * SizeOf(real)));
  451.         if mMin = nil then
  452.             abort;
  453.         mMax := MaxPtr(NewPtr(nItems * SizeOf(real)));
  454.         if mMax = nil then
  455.             abort;
  456.         plength := plengthPtr(NewPtr(nItems * SizeOf(real)));
  457.         if plength = nil then
  458.             abort;
  459.         User1 := User1Ptr(NewPtr(nItems * SizeOf(real)));
  460.         if User1 = nil then
  461.             abort;
  462.         for i := 0 to MaxMeasurements do
  463.             User1^[i] := 0.0;
  464.         User2 := User2Ptr(NewPtr(nItems * SizeOf(real)));
  465.         if User2 = nil then
  466.             abort;
  467.         for i := 0 to MaxMeasurements do
  468.             User2^[i] := 0.0;
  469.         ClearResults(0);
  470.         if FreeMem < MinFree then
  471.             Abort;
  472.     end;
  473.  
  474.  
  475.     procedure GetKernelsWorkingDir (var settings: SettingsType);
  476.         var
  477.             wdRefNum: integer;
  478.             err: OSErr;
  479.     begin
  480.         with settings do
  481.             if sKernelsVRefNum <> 0 then
  482.                 begin
  483.                     err := OpenWD(sKernelsVRefNum, sKernelsDirID, 0, wdRefNum);
  484.                     if err = NoErr then
  485.                         KernelsRefNum := wdRefNum;
  486.           {ShowMessage(concat('KernelsRefNum=', long2str(KernelsRefNum), crStr, 'vRefNum=', long2str(sKernelsVRefNum), crStr, 'DirID=', long2str(sKernelsDirID)));}
  487.                 end;
  488.     end;
  489.  
  490.  
  491.     procedure GetDefaultWorkingDir (var settings: SettingsType);
  492.         var
  493.             wdRefNum: integer;
  494.             err: OSErr;
  495.     begin
  496.         with settings do
  497.             if sDefaultVRefNum <> 0 then
  498.                 begin
  499.                     err := OpenWD(sDefaultVRefNum, sDefaultDirID, 0, wdRefNum);
  500.                     if err = NoErr then
  501.                         DefaultRefNum := wdRefNum;
  502.                 end;
  503.     end;
  504.  
  505.  
  506.  
  507. procedure GetPreferences(f: integer);
  508.         var
  509.             err: OSErr;
  510.             ByteCount: LongInt;
  511.             ok: boolean;
  512.             size: LongInt;
  513.             settings: SettingsType;
  514.             i: integer;
  515.             SaveInfo: InfoPtr;
  516.             okay: boolean;
  517.     begin
  518.         err := GetEof(f, ByteCount);
  519.         if ByteCount > SizeOf(settings) then
  520.             ByteCount := SizeOf(settings);
  521.         err := fsRead(f, ByteCount, @settings);
  522.         if err <> NoErr then
  523.             exit(GetPreferences);
  524.         err := fsClose(f);
  525.         with settings, info^ do
  526.             begin
  527.                 if sID <> 'IMAG' then begin
  528.                         PutError('The "Image Prefs" file in the System folder is corrupted. Please delete it and try again.');
  529.                         exitToShell;
  530.                     end;
  531.                 ForegroundIndex := sForegroundIndex;
  532.                 BackgroundIndex := sBackgroundIndex;
  533.                 BrushHeight := sBrushHeight;
  534.                 BrushWidth := sBrushWidth;
  535.                 SprayCanDiameter := sSprayCanDiameter;
  536.                 SprayCanRadius := SprayCanDiameter div 2;
  537.                 SprayCanRadius2 := SprayCanRadius * SprayCanRadius;
  538.                 CurrentFontID := sCurrentFontID;
  539.                 CurrentStyle := SCurrentStyle;
  540.                 CurrentSize := sCurrentSize;
  541.                 TextJust := sTextJust;
  542.                 TextBack := sTextBack;
  543.                 nExtraColors := sNExtraColors;
  544.                 ExtraColors := sExtraColors;
  545.                 InvertVideo := sInvertVideo;
  546.                 Measurements := sMeasurements;
  547.                 InvertPlots := sInvertPlots;
  548.                 AutoScalePlots := sAutoScalePlots;
  549.                 LinePlot := sLinePlot;
  550.                 DrawPlotLabels := sDrawPlotLabels;
  551.                 FixedSizePlot := sFixedSizePlot;
  552.                 ProfilePlotWidth := sProfilePlotWidth;
  553.                 ProfilePlotHeight := sProfilePlotHeight;
  554.                 FramesToAverage := sFramesToAverage;
  555.                 NewPicWidth := sNewPicWidth;
  556.                 NewPicHeight := sNewPicHeight;
  557.                 BufferSize := sBufferSize;
  558.                 ThresholdToForeground := sThresholdToForeground;
  559.                 NonThresholdToBackground := sNonThresholdToBackground;
  560.                 VideoChannel := sVideoChannel;
  561.                 WhatToImport := sWhatToImport;
  562.                 ImportCustomWidth := sImportCustomWidth;
  563.                 ImportCustomHeight := sImportCustomHeight;
  564.                 ImportCustomOffset := sImportCustomOffset;
  565.         {WandAutoMeasure := sWandAutoMeasure;}
  566.                 WandAdjustAreas := sWandAdjustAreas;
  567.                 BinaryIterations := sBinaryIterations;
  568.                 ScaleArithmetic := sScaleArithmetic;
  569.                 InvertPixelValues := sInvertPixelValues;
  570.                 InvertYCoordinates := sInvertYCoordinates;
  571.                 FieldWidth := sFieldWidth;
  572.                 precision := sPrecision;
  573.                 MinParticleSize := sMinParticleSize;
  574.                 MaxParticleSize := sMaxParticleSize;
  575.                 IgnoreParticlesTouchingEdge := sIgnoreParticlesTouchingEdge;
  576.                 LabelParticles := sLabelParticles;
  577.                 OutlineParticles := sOutlineParticles;
  578.          {IncludeHoles := sIncludeHoles;}
  579.                 OscillatingMovies := sOscillatingMovies;
  580.          {DriverHalftoning := sDriverHalftoning;}
  581.                 MaxMeasurements := sMaxMeasurements;
  582.                 ImportCustomDepth := sImportCustomDepth;
  583.                 ImportSwapBytes := sImportSwapBytes;
  584.                 ImportCalibrate := sImportCalibrate;
  585.                 ImportAutoscale := sImportAutoscale;
  586.                 ShowHeadings := sShowHeadings;
  587.                 if sVersion >= 140 then
  588.                     begin
  589.                         ProfilePlotMin := sProfilePlotMin;
  590.                         ProfilePlotMax := sProfilePlotMax;
  591.                         ImportMin := sImportMin;
  592.                         ImportMax := sImportMax;
  593.                         HighlightSaturatedPixels := sHighlightPixels;
  594.                     end;
  595.                 if sVersion >= 141 then
  596.                     begin
  597.                         BallRadius := sBallRadius;
  598.                         FasterBackgroundSubtraction := sFasterBackgroundSubtraction;
  599.                         ScaleConvolutions := sScaleConvolutions;
  600.                     end;
  601.                 if sVersion >= 142 then
  602.                     begin
  603.                         BinaryCount := sBinaryCount;
  604.                         BinaryThreshold := BinaryCount * 255;
  605.                         if (not GrayMapReady) and (sLUTMode = Pseudocolor) and (sColorTable <> CustomTable) and (sColorTable <= Spectrum) then
  606.                             begin
  607.                                 ColorTable := sColorTable;
  608.                                 ColorStart := sColorStart;
  609.                                 ColorEnd := sColorEnd;
  610.                                 LutMode := Pseudocolor;
  611.                                 InvertedColorTable := sInvertedTable;
  612.                             end;
  613.                     end;
  614.                 if sVersion >= 144 then
  615.                     begin
  616.                         HalftoneFrequency := sHalftoneFrequency;
  617.                         HalftoneAngle := sHalftoneAngle;
  618.                         HalftoneDotFunction := sHalftoneDotFunction;
  619.                     end;
  620.                 if sVersion >= 146 then
  621.                     begin
  622.                         DacLow := sDacLow;
  623.                         DacHigh := sDacHigh;
  624.                     end;
  625.                 if (sVersion >= 147) and ((FrameGrabber = ScionLG3) or (FrameGrabber = ScionAG5) or (FrameGrabber = ScionVG5f)) then
  626.                     SyncMode := sSyncMode;
  627.                 if sVersion >= 149 then
  628.                     begin
  629.                         SwitchLUTOnSuspend := sSwitchLUTOnSuspend;
  630.                         VideoRateAveraging := sVideoRateAveraging;
  631.                     end;
  632.                 if sVersion >= 150 then
  633.                     begin
  634.                         ImportInvert := sImportInvert;
  635.                     end;
  636.                 if sVersion >= 152 then
  637.                     begin
  638.                         if sTextCreator[1] <> chr(0) then
  639.                             TextCreator := sTextCreator;
  640.                     end;
  641.                 if sVersion >= 156 then
  642.                     begin
  643.                         if sMathSubGain <> 0.0 then begin
  644.                             MathSubGain:=sMathSubGain;
  645.                             MathSubOffset:=sMathSubOffset;
  646.                             MathGain:=MathSubGain;
  647.                             MathOffset:=MathSubOffset;
  648.                         end;
  649.                     end;
  650.                 if sVersion >= 160 then begin
  651.                         fgScale := sfgScale;
  652.                         UseBuiltinDigitizer := sUseBuiltinDigitizer;
  653.                         DigitizerMode := sDigitizerMode;
  654.                         DigitizerStandard := sDigitizerStandard;
  655.                         LutFriendlyMode := sLutFriendlyMode;
  656.                     end;
  657.                 {GetKernelsWorkingDir(settings);}
  658.                 {GetDefaultWorkingDir(settings);}
  659.                 UpdateFitEllipse;
  660.             end; {with}
  661.     end;
  662.     
  663.     
  664.     procedure GetSettings;
  665.         var
  666.             err: OSErr;
  667.             f: integer;
  668.             ByteCount: LongInt;
  669.             ok: boolean;
  670.             size: LongInt;
  671.             settings: SettingsType;
  672.             i: integer;
  673.             PrefsFound:boolean;
  674.             PrefsVRef: integer;
  675.             PrefsDirID: LongInt;
  676.             PrefsSpec: FSSpec;
  677.     begin
  678.         PrefsFound:=false;
  679.         if System7 then begin
  680.             {Look in the Preferences folder}
  681.             err:=FindFolder(kOnSystemDisk, kPreferencesFolderType,
  682.                         kDontCreateFolder, PrefsVRef, PrefsDirID);
  683.             if err=noErr then
  684.                 err:=FSMakeFSSpec(PrefsVRef, PrefsDirID, PrefsName, PrefsSpec);
  685.             if err=noErr then
  686.                 err:=FSpOpenDF(PrefsSpec, fsCurPerm, f);
  687.             if err=noErr then
  688.                 PrefsFound:=true;
  689.         end;
  690.         if not PrefsFound then begin
  691.             {Look in the System folder}
  692.             err := fsopen(PrefsName, SystemRefNum, f);
  693.             if err <> NoErr then
  694.                 exit(GetSettings);
  695.         end;
  696.         GetPreferences(f);
  697.     end;
  698.  
  699.  
  700.     procedure MakePatterns;
  701. {Creates the patterns used to create the "marching ants". Thanks to}
  702. {Seth Snyder on CompuServe for the example.}
  703.         var
  704.             i, j: Integer;
  705.     begin
  706.         j := 0;
  707.         for i := 0 to 7 do
  708.             begin
  709.                 AntPattern[i].pat[(j + 0) mod 8] := $1F;
  710.                 AntPattern[i].pat[(j + 1) mod 8] := $3E;
  711.                 AntPattern[i].pat[(j + 2) mod 8] := $7C;
  712.                 AntPattern[i].pat[(j + 3) mod 8] := $F8;
  713.                 AntPattern[i].pat[(j + 4) mod 8] := $F1;
  714.                 AntPattern[i].pat[(j + 5) mod 8] := $E3;
  715.                 AntPattern[i].pat[(j + 6) mod 8] := $C7;
  716.                 AntPattern[i].pat[(j + 7) mod 8] := $8F;
  717.                 j := j + 1;
  718.             end;
  719.         PatIndex := 0;
  720.     end;
  721.  
  722.  
  723.     procedure InitExtraColors;
  724.         var
  725.             i, j, ctop, cbottom, entry: integer;
  726.             tRect: rect;
  727.     begin
  728.         with ExtraColors[1] do
  729.             begin
  730.                 red := -1;
  731.                 green := 0;
  732.                 blue := 0;
  733.             end;
  734.         with ExtraColors[2] do
  735.             begin
  736.                 red := 0;
  737.                 green := -1;
  738.                 blue := 0;
  739.             end;
  740.         with ExtraColors[3] do
  741.             begin
  742.                 red := 0;
  743.                 green := 0;
  744.                 blue := -1;
  745.             end;
  746.         with ExtraColors[4] do
  747.             begin
  748.                 red := -1;
  749.                 green := -1;
  750.                 blue := 0;
  751.             end;
  752.         with ExtraColors[5] do
  753.             begin
  754.                 red := 0;
  755.                 green := -1;
  756.                 blue := -1;
  757.             end;
  758.         with ExtraColors[6] do
  759.             begin
  760.                 red := -1;
  761.                 green := 0;
  762.                 blue := -1;
  763.             end;
  764.         ctop := 256;
  765.         cbottom := ctop + ExtraColorsHeight;
  766.         for i := 1 to MaxExtraPlus2 do
  767.             begin
  768.                 SetRect(tRect, 0, ctop, cwidth, cbottom);
  769.                 ExtraColorsRect[i] := tRect;
  770.                 ctop := ctop + ExtraColorsHeight;
  771.                 cbottom := cbottom + ExtraColorsHeight;
  772.             end;
  773.         ExtraColorsEntry[1] := WhiteIndex;
  774.         ExtraColorsEntry[2] := BlackIndex;
  775.         entry := FirstExtraColorsEntry;
  776.         j := 3;
  777.         for i := 1 to MaxExtraColors do
  778.             begin
  779.                 ExtraColorsEntry[j] := entry;
  780.                 j := j + 1;
  781.                 Entry := Entry + 1;
  782.             end;
  783.     end;
  784.  
  785.  
  786.     function GetSlotBase (id: integer): LongInt;
  787.   {Returns the slot base address of the NuBus card with the specified id. The address}
  788.   {returned is in the form $Fss00000, which is valid in both 24 and 32-bit modes.}
  789.   {Returns 0 if a card with the given id is not found.}
  790.         type
  791.             SPRAMRecord = packed record
  792.                     BoardId: integer;
  793.                     VenderUse: packed array[1..6] of SignedByte;
  794.                 end;
  795.         var
  796.             SlotBlock: SpBlock;
  797.             sparm: SPRAMRecord;
  798.             SparmAddr: LongInt;
  799.             i: integer;
  800.             err: OSErr;
  801.     begin
  802.         with SlotBlock do
  803.             begin
  804.                 SparmAddr := LongInt(@sparm);
  805.                 spResult := SparmAddr;
  806.                 for i := 9 to 15 do
  807.                     begin
  808.                         spSlot := i;
  809.                         err := sReadPRAMRec(@SlotBlock);
  810.                         if sparm.BoardID = id then
  811.                             begin
  812.                                 GetSlotBase := bor($F0000000, spSlot * $100000 + spSlot * $1000000);
  813.                 superSlotBase := spSlot * $10000000;
  814.                                 exit(GetSlotBase)
  815.                             end;
  816.                     end;
  817.                 GetSlotBase := 0;
  818.             end;
  819.     end;
  820.  
  821.  
  822.     procedure SetupFGPort;
  823. {So we can use CopyBits, this routine sets up a color graf port that}
  824. {uses the memory on the frame grabber board as the PixMap.}
  825.         const
  826.             baseAddr32 = 4;
  827.         var
  828.             tPort: GrafPtr;
  829.             trect: rect;
  830.             SaveGDevice: GDHandle;
  831.     begin
  832.         SaveGDevice := GetGDevice;
  833.         SetGDevice(osGDevice);
  834.         GetPort(tPort);
  835.         fgPort := CGrafPtr(NewPtr(SizeOf(CGrafPort)));
  836.         OpenCPort(fgPort);
  837.         SetRect(trect, 0, 0, fgWidth, fgHeight);
  838.         with fgPort^ do
  839.             begin
  840.                 with PortPixMap^^ do
  841.                     begin
  842.                         if PCIFrameGrabber then
  843.                             BaseAddr := ptr(fgSuperSlotBase0)
  844.                         else
  845.                             BaseAddr := ptr(fgSlotBase);
  846.                         bounds := trect;
  847.                         RowBytes := BitOr(fgRowBytes, $8000);
  848.                         pmVersion := baseAddr32; {Needed for 8*24 GC card. See TN 275.}
  849.                     end;
  850.                 PortRect := trect;
  851.                 RectRgn(visRgn, trect);
  852.             end;
  853.         hlock(handle(fgPort^.PortPixMap));
  854.         fgPixMap := fgPort^.PortPixMap;
  855.         SetPort(tPort);
  856.         SetPalette(WindowPtr(fgPort), ExplicitPalette, false);
  857.         SetGDevice(SaveGDevice);
  858.     end;
  859.  
  860.  
  861.     function is50HzLG3: boolean;
  862.         const
  863.             BoardResourceID = 1;
  864.             VendorInfoID = 36;
  865.             PartNumberID = 4;
  866.             PartNumber50Hz = 'LG-3 50Hz';
  867.         var
  868.             SlotBlock: SpBlock;
  869.             err: OSErr;
  870.             PartNumberPtr: StringPtr;
  871.     begin
  872.         is50HzLG3 := false;
  873.         SlotBlock.spSlot := byte(bsr(band(fgSlotBase, $0f000000), 24));
  874.         SlotBlock.spId := BoardResourceID;
  875.         SlotBlock.spExtDev := 0;
  876.         err := SRsrcInfo(@SlotBlock);
  877.         if err <> 0 then
  878.             exit(is50HzLG3);
  879.         SlotBlock.spId := VendorInfoID;
  880.         err := SFindStruct(@SlotBlock);
  881.         if err <> 0 then
  882.             exit(is50HzLG3);
  883.         SlotBlock.spID := PartNumberID;
  884.         err := SGetCString(@SlotBlock);
  885.         if err <> 0 then
  886.             exit(is50HzLG3);
  887.         PartNumberPtr := C2PStr(SlotBlock.spResult);
  888.         if PartNumberPtr^ = PartNumber50Hz then
  889.             is50HzLG3 := true;
  890.         DisposePtr(Ptr(SlotBlock.spResult)); {need to free memory allocated by SGetCString()}
  891.     end;
  892.  
  893.  
  894.     function is50HzAG5: boolean;
  895.         const
  896.             BoardResourceID = 1;
  897.             VendorInfoID = 36;
  898.             PartNumberID = 4;
  899.             PartNumber50Hz = 'AG-5 50Hz';
  900.         var
  901.             SlotBlock: SpBlock;
  902.             err: OSErr;
  903.             PartNumberPtr: StringPtr;
  904.     begin
  905.         is50HzAG5 := false;
  906.         SlotBlock.spSlot := byte(bsr(band(fgSlotBase, $0f000000), 24));
  907.         SlotBlock.spId := BoardResourceID;
  908.         SlotBlock.spExtDev := 0;
  909.         err := SRsrcInfo(@SlotBlock);
  910.         if err <> 0 then
  911.             exit(is50HzAG5);
  912.         SlotBlock.spId := VendorInfoID;
  913.         err := SFindStruct(@SlotBlock);
  914.         if err <> 0 then
  915.             exit(is50HzAG5);
  916.         SlotBlock.spID := PartNumberID;
  917.         err := SGetCString(@SlotBlock);
  918.         if err <> 0 then
  919.             exit(is50HzAG5);
  920.         PartNumberPtr := C2PStr(SlotBlock.spResult);
  921.         if PartNumberPtr^ = PartNumber50Hz then
  922.             is50HzAG5 := true;
  923.         DisposePtr(Ptr(SlotBlock.spResult));  {need to free memory allocated by SGetCString()}
  924.     end;
  925.  
  926.  
  927.     function is50HzVG5: boolean;
  928.         const
  929.             BoardResourceID = 1;
  930.             VendorInfoID = 36;
  931.             PartNumberID = 4;
  932.             PartNumber50Hz = 'VG-5 50Hz';
  933.         var
  934.             SlotBlock: SpBlock;
  935.             err: OSErr;
  936.             PartNumberPtr: StringPtr;
  937.     begin
  938.         is50HzVG5 := false;
  939.         SlotBlock.spSlot := byte(bsr(band(fgSlotBase, $0f000000), 24));
  940.         SlotBlock.spId := BoardResourceID;
  941.         SlotBlock.spExtDev := 0;
  942.         err := SRsrcInfo(@SlotBlock);
  943.         if err <> 0 then
  944.             exit(is50HzVG5);
  945.         SlotBlock.spId := VendorInfoID;
  946.         err := SFindStruct(@SlotBlock);
  947.         if err <> 0 then
  948.             exit(is50HzVG5);
  949.         SlotBlock.spID := PartNumberID;
  950.         err := SGetCString(@SlotBlock);
  951.         if err <> 0 then
  952.             exit(is50HzVG5);
  953.         PartNumberPtr := C2PStr(SlotBlock.spResult);
  954.         if PartNumberPtr^ = PartNumber50Hz then
  955.             is50HzVG5 := true;
  956.         DisposePtr(Ptr(SlotBlock.spResult)); {need to free memory allocated by SGetCString()}
  957.     end;
  958.  
  959.  
  960.  procedure CheckLG3Buffer;
  961.   type
  962.    LongintPtr = ^Longint;
  963.   const
  964.    Pattern = $A596A596;
  965.   var
  966.    BufferPtr: LongintPtr;
  967.    mode: signedbyte;
  968.    
  969.    procedure SwapMode;
  970.    begin
  971.       {$ifc not PowerPC}
  972.       SwapMMUMode(mode);
  973.       {$endc}
  974.    end;
  975.    
  976.  begin
  977.   mode := true32b;
  978.   SwapMode;
  979.   BufferPtr := LongintPtr(fgSlotBase);
  980.   BufferPtr^ := Pattern;
  981.   BufferPtr := LongintPtr(bsl(band(fgSlotBase, $0f000000), 4) + (524288 * 2));
  982.   if BufferPtr^ = Pattern then begin
  983.     MaxLG3Frames := 2;
  984.       SwapMode;
  985.     exit(CheckLG3Buffer);
  986.    end;
  987.   BufferPtr := LongintPtr(bsl(band(fgSlotBase, $0f000000), 4) + (524288 * 8));
  988.   if BufferPtr^ = Pattern then begin
  989.     MaxLG3Frames := 8;
  990.       SwapMode;
  991.     exit(CheckLG3Buffer);
  992.    end;
  993.   BufferPtr := LongintPtr(bsl(band(fgSlotBase, $0f000000), 4) + (524288 * 32));
  994.   if BufferPtr^ = Pattern then begin
  995.     MaxLG3Frames := 32;
  996.       SwapMode;
  997.     exit(CheckLG3Buffer);
  998.    end
  999.   else begin
  1000.     MaxLG3Frames := 128;
  1001.       SwapMode;
  1002.    end;
  1003.  end;
  1004.  
  1005.  
  1006.     procedure LookForFrameGrabbers;
  1007.         const
  1008.             ControlRegOffset = $80000;
  1009.             ChannelRegOffset = $80004;
  1010.             LG3ControlRegOffset = $C0000;
  1011.             LG3ChannelRegOffset = $C0008;
  1012.             AG5ControlRegOffset = $C0000;
  1013.             AG5ChannelRegOffset = $C0008;
  1014.             AG5BufferRegOffset = $C0014;
  1015.             VG5ControlRegOffset = $C0000;
  1016.             VG5ChannelRegOffset = $C0008;
  1017.             VG5BufferRegOffset = $C0014;
  1018.             BufferRegOffset = $C0004;
  1019.             DacHighRegOffset = $C000C;
  1020.             DacLowRegOffset = $C0010;
  1021.             DacARegOffset = $C0014;
  1022.             DacBRegOffset = $C0018;
  1023.             ConstantRegOffset = $C0004;
  1024.             ScaleHighRegOffset = $D0000;
  1025.             ScaleLowRegOffset = $D0004;
  1026.             DT2255id = $11A;
  1027.             ScionLG3id = $48B;
  1028.             ScionAG5id = $620;
  1029.             ScionVG5id = $67E;
  1030.             ScionLG3PCIid = 1;
  1031.             ScionVG5PCIid = 2;
  1032.             ScionAG5PCIid = 3;
  1033.             PalBufferSize = 393216; {768 x 512}
  1034.         var
  1035.             err: OSErr;
  1036.             tPort: GrafPtr;
  1037.             OptionKeyIsDown: boolean;
  1038.             found : boolean;
  1039.             model: integer;
  1040.             base0, base1, buffers: longint;
  1041.     begin
  1042.         FrameGrabber := NoFrameGrabber;
  1043.         PCIFrameGrabber := false;
  1044.         DoubleBuffering := false;
  1045.         fgPixMap := nil;
  1046.         DacLow := DefaultDacLow;
  1047.         DacHigh := DefaultDacHigh;
  1048.         if ShiftKeyDown then
  1049.             exit(LookForFrameGrabbers);
  1050.         OptionKeyIsDown := OptionKeyDown;
  1051.         fgPort := nil;
  1052.         
  1053.         {Scion LG-3}
  1054.         fgSlotBase := GetSlotBase(ScionLG3id);
  1055.         fgRowBytes := 1024;
  1056.         if (fgSlotBase <> 0) and not OptionKeyIsDown then begin
  1057.                 FrameGrabber := ScionLG3;
  1058.                 ControlReg := ptr(fgSlotBase + LG3ControlRegOffset);
  1059.                 ChannelReg := ptr(fgSlotBase + LG3ChannelRegOffset);
  1060.                 BufferReg := ptr(fgSlotBase + BufferRegOffset);
  1061.                 DacHighReg := ptr(fgSlotBase + DacHighRegOffset);
  1062.                 DacLowReg := ptr(fgSlotBase + DacLowRegOffset);
  1063.                 DacAReg := ptr(fgSlotBase + DacARegOffset);
  1064.                 DacBReg := ptr(fgSlotBase + DacBRegOffset);
  1065.                 fgWidth := 640;
  1066.                 fgHeight := 480;
  1067.                 if is50HzLG3 then begin
  1068.                         fgWidth := 768;
  1069.                         fgHeight := 512;
  1070.                         if BufferSize < PalBufferSize then
  1071.                             BufferSize := PalBufferSize;
  1072.                     end;
  1073.                 CheckLG3Buffer;
  1074.                 SetupFGPort;
  1075.                 ResetScionLG3;
  1076.                 exit(LookForFrameGrabbers);
  1077.             end;
  1078.             
  1079.         {Scion AG-5}
  1080.         fgSlotBase := GetSlotBase(ScionAG5id);
  1081.         if (fgSlotBase <> 0) and not OptionKeyIsDown then begin
  1082.                 FrameGrabber := ScionAG5;
  1083.                 ControlReg := ptr(fgSlotBase + AG5ControlRegOffset);
  1084.                 ChannelReg := ptr(fgSlotBase + AG5ChannelRegOffset);
  1085.                 ConstantReg := ptr(fgSlotBase + ConstantRegOffset);
  1086.                 DacHighReg := ptr(fgSlotBase + DacHighRegOffset);
  1087.                 DacLowReg := ptr(fgSlotBase + DacLowRegOffset);
  1088.                 ScaleHighReg := IntegerPtr(fgSlotBase + ScaleHighRegOffset);
  1089.                 ScaleLowReg := IntegerPtr(fgSlotBase + ScaleLowRegOffset);
  1090.                 fgWidth := 640;
  1091.                 fgHeight := 480;
  1092.                 if is50HzAG5 then begin
  1093.                         fgWidth := 768;
  1094.                         fgHeight := 512;
  1095.                         if BufferSize < PalBufferSize then
  1096.                             BufferSize := PalBufferSize;
  1097.                     end;
  1098.                 SetupFGPort;
  1099.                 ResetScionAG5;
  1100.                 exit(LookForFrameGrabbers);
  1101.             end;
  1102.             
  1103.         {Scion VG-5}
  1104.         fgSlotBase := GetSlotBase(ScionVG5id);
  1105.         if (fgSlotBase <> 0) and not OptionKeyIsDown then begin
  1106.                 FrameGrabber := ScionVG5f;
  1107.                 ControlReg := ptr(fgSlotBase + VG5ControlRegOffset);
  1108.                 ChannelReg := ptr(fgSlotBase + VG5ChannelRegOffset);
  1109.                 DacHighReg := ptr(fgSlotBase + DacHighRegOffset);
  1110.                 DacLowReg := ptr(fgSlotBase + DacLowRegOffset);
  1111.                 fgWidth := 640;
  1112.                 fgHeight := 480;
  1113.                 if is50HzVG5 then begin
  1114.                         fgWidth := 768;
  1115.                         fgHeight := 512;
  1116.                         if BufferSize < PalBufferSize then
  1117.                             BufferSize := PalBufferSize;
  1118.                     end;
  1119.                 SetupFGPort;
  1120.                 ResetScionVG5f;
  1121.                 exit(LookForFrameGrabbers);
  1122.             end;
  1123.             
  1124.         {Data Translation QuickCapture}
  1125.         fgSlotBase := GetSlotBase(DT2255id);
  1126.         if fgSlotBase <> 0 then begin
  1127.                 FrameGrabber := QuickCapture;
  1128.                 ControlReg := ptr(fgSlotBase + ControlRegOffset);
  1129.                 ChannelReg := ptr(fgSlotBase + ControlRegOffset + 4);
  1130.                 fgWidth := 640;
  1131.                 fgHeight := 480;
  1132.                 if band(ChannelReg^, 8) = 8 then begin {Check for 50Hz(PAL) card}
  1133.                         fgWidth := 768;
  1134.                         fgHeight := 512;
  1135.                         if BufferSize < PalBufferSize then
  1136.                             BufferSize := PalBufferSize;
  1137.                     end;
  1138.                 SetupFGPort;
  1139.                 ResetQuickCapture;
  1140.                 exit(LookForFrameGrabbers);
  1141.             end;
  1142.             
  1143.             {$ifc PowerPC and SupportScionPCI}
  1144.             
  1145.             {Scion LG-3 (PCI)}
  1146.             model := ScionLG3PCIid;
  1147.             base0 := 0;
  1148.             base1 := 0;
  1149.             buffers:= 0;
  1150.             found := false;
  1151.             found := LookForPCIFrameGrabbers(model, base0, base1, buffers);
  1152.             if found then begin
  1153.                 fgSlotBase := base0;
  1154.                 fgSuperSlotBase0 := base1;
  1155.                 fgSuperSlotBase1 := base1 + 524288;
  1156.                 FrameGrabber := ScionLG3;
  1157.                 PCIFrameGrabber := true;
  1158.                 ControlReg := ptr(fgSlotBase + LG3ControlRegOffset);
  1159.                 ChannelReg := ptr(fgSlotBase + LG3ChannelRegOffset);
  1160.                 BufferReg := ptr(fgSlotBase + BufferRegOffset);
  1161.                 DacHighReg := ptr(fgSlotBase + DacHighRegOffset);
  1162.                 DacLowReg := ptr(fgSlotBase + DacLowRegOffset);
  1163.                 DacAReg := ptr(fgSlotBase + DacARegOffset);
  1164.                 DacBReg := ptr(fgSlotBase + DacBRegOffset);
  1165.                 fgWidth := 640;
  1166.                 fgHeight := 480;
  1167.                 if (band(ControlReg^, $40) <> 0) then begin
  1168.                         fgWidth := 768;
  1169.                         fgHeight := 512;
  1170.                         if BufferSize < PalBufferSize then
  1171.                             BufferSize := PalBufferSize;
  1172.                     end;
  1173.                 MaxLG3Frames := buffers;
  1174.                 SetupFGPort;
  1175.                 ResetScionLG3;
  1176.                 exit(LookForFrameGrabbers);
  1177.             end;
  1178.             
  1179.             {Scion VG-5 PCI}
  1180.             model := ScionVG5PCIid;
  1181.             base0 := 0;
  1182.             base1 := 0;
  1183.             buffers:= 0;
  1184.             found := false;
  1185.             found := LookForPCIFrameGrabbers(model, base0, base1, buffers);
  1186.             if (found) then begin
  1187.                     fgSlotBase := base0;
  1188.                     fgSuperSlotBase0 := base1;
  1189.                     fgSuperSlotBase1 := base1 + 524288;
  1190.                     FrameGrabber := ScionVG5f;
  1191.                     PCIFrameGrabber := true;
  1192.                     ControlReg := ptr(fgSlotBase + VG5ControlRegOffset);
  1193.                     ChannelReg := ptr(fgSlotBase + VG5ChannelRegOffset);
  1194.                     BufferReg := ptr(fgSlotBase + VG5BufferRegOffset);
  1195.                     DacHighReg := ptr(fgSlotBase + DacHighRegOffset);
  1196.                     DacLowReg := ptr(fgSlotBase + DacLowRegOffset);
  1197.                     fgWidth := 640;
  1198.                     fgHeight := 480;
  1199.                     if (band(ControlReg^, $40) <> 0) then begin
  1200.                             fgWidth := 768;
  1201.                             fgHeight := 512;
  1202.                             if BufferSize < PalBufferSize then
  1203.                                 BufferSize := PalBufferSize;
  1204.                         end;
  1205.                     SetupFGPort;
  1206.                     ResetScionVG5f;
  1207.                     exit(LookForFrameGrabbers);
  1208.                 end;
  1209.             
  1210.             {Scion AG-5 PCI}
  1211.             model := ScionAG5PCIid;
  1212.             base0 := 0;
  1213.             base1 := 0;
  1214.             buffers:= 0;
  1215.             found := false;
  1216.             found := LookForPCIFrameGrabbers(model, base0, base1, buffers);
  1217.             if (found) then begin
  1218.                     fgSlotBase := base0;
  1219.                     fgSuperSlotBase0 := base1;
  1220.                     fgSuperSlotBase1 := base1 + 2097152;
  1221.                     FrameGrabber := ScionAG5;
  1222.                     PCIFrameGrabber := true;
  1223.                     ControlReg := ptr(fgSlotBase + AG5ControlRegOffset);
  1224.                     ChannelReg := ptr(fgSlotBase + AG5ChannelRegOffset);
  1225.                     ConstantReg := ptr(fgSlotBase + ConstantRegOffset);
  1226.                     BufferReg := ptr(fgSlotBase + AG5BufferRegOffset);
  1227.                     DacHighReg := ptr(fgSlotBase + DacHighRegOffset);
  1228.                     DacLowReg := ptr(fgSlotBase + DacLowRegOffset);
  1229.                     ScaleHighReg := IntegerPtr(fgSlotBase + ScaleHighRegOffset);
  1230.                     ScaleLowReg := IntegerPtr(fgSlotBase + ScaleLowRegOffset);
  1231.                     fgWidth := 640;
  1232.                     fgHeight := 480;
  1233.                     if (band(ControlReg^, $40) <> 0) then begin
  1234.                             fgWidth := 768;
  1235.                             fgHeight := 512;
  1236.                             if BufferSize < PalBufferSize then
  1237.                                 BufferSize := PalBufferSize;
  1238.                         end;
  1239.                     SetupFGPort;
  1240.                     ResetScionAG5;
  1241.                     exit(LookForFrameGrabbers);
  1242.                 end;
  1243.  
  1244.             {$endc} {if PowerPC}
  1245.  
  1246.     end; {LookForFrameGrabbers}
  1247.  
  1248.  
  1249.     procedure CheckBits;
  1250.         const
  1251.             QD32Trap = $AB03;
  1252.             UnimplementedTrap = $A89F;
  1253.         var
  1254.             MainDevice: GDHandle;
  1255.             myEnvRec: SysEnvRec;
  1256.             err: OSErr;
  1257.     begin
  1258.         err := SysEnvirons(1, myEnvRec);
  1259.         if err <> envNotPresent then
  1260.             with MyEnvRec do
  1261.                 begin
  1262.                     if not HasColorQD then
  1263.                         begin
  1264.                             PutError('Sorry, NIH Image requires a Macintosh with Color QuickDraw.');
  1265.                             ExitToShell;
  1266.                         end;
  1267.                     if not HasFPU and UsingFPU then
  1268.                         begin
  1269.                             PutError('Use the NonFPU version of NIH Image on Macs without a floating-point coprocessor.');
  1270.                             ExitToShell;
  1271.                         end;
  1272.                     OldSystem := systemVersion < $0605;
  1273.                     System7 := systemVersion >= $0700;
  1274.                     if not System7 then
  1275.                         begin
  1276.                             PutError('System 7 required.');
  1277.                             if not OptionKeyDown then
  1278.                                 ExitToShell;
  1279.                         end;
  1280.                     SystemRefnum := sysVRefNum;
  1281.                 end;
  1282.         Has32BitQuickDraw := nGetTrapAddress(QD32Trap, ToolTrap) <> nGetTrapAddress(UnimplementedTrap, ToolTrap);
  1283.         MainDevice := GetMainDevice;
  1284.         ScreenPixMap := MainDevice^^.gdPMap;
  1285.         ScreenRowBytes := BitAnd(ScreenPixMap^^.rowBytes, $1fff);
  1286.         ScreenBase := ScreenPixMap^^.baseAddr;
  1287.         FindMonitors(ScreenPixMap^^.PixelSize);
  1288.     end;
  1289.  
  1290.  
  1291.     procedure SetupMenus;
  1292.         var
  1293.             i: integer;
  1294.     begin
  1295.         AppleMenuH := GetMenu(AppleMenu);
  1296.         InsertMenu(AppleMenuH, 0);
  1297.         FileMenuH := GetMenu(FileMenu);
  1298.         InsertMenu(FileMenuH, 0);
  1299.         EditMenuH := GetMenu(EditMenu);
  1300.         InsertMenu(EditMenuH, 0);
  1301.         OptionsMenuH := GetMenu(OptionsMenu);
  1302.         InsertMenu(OptionsMenuH, 0);
  1303.         ProcessMenuH := GetMenu(ProcessMenu);
  1304.         InsertMenu(ProcessMenuH, 0);
  1305.         AnalyzemenuH := GetMenu(AnalyzeMenu);
  1306.         InsertMenu(AnalyzemenuH, 0);
  1307.         SpecialMenuH := GetMenu(SpecialMenu);
  1308.         InsertMenu(SpecialMenuH, 0);
  1309.         StacksMenuH := GetMenu(StacksMenu);
  1310.         InsertMenu(StacksMenuH, 0);
  1311.         WindowsMenuH := GetMenu(WindowsMenu);
  1312.         InsertMenu(WindowsMenuH, 0);
  1313.  
  1314.         FontMenuH := GetMenu(FontMenu);
  1315.         InsertMenu(FontMenuH, -1);
  1316.         SizeMenuH := GetMenu(SizeMenu);
  1317.         InsertMenu(SizeMenuH, -1);
  1318.         StyleMenuH := GetMenu(StyleMenu);
  1319.         InsertMenu(StyleMenuH, -1);
  1320.         BinaryMenuH := GetMenu(BinaryMenu);
  1321.         InsertMenu(BinaryMenuH, -1);
  1322.         ArithmeticMenuH := GetMenu(ArithmeticMenu);
  1323.         InsertMenu(ArithmeticMenuH, -1);
  1324.         fftMenuH := GetMenu(fftMenu);
  1325.         InsertMenu(fftMenuH, -1);
  1326.         BackgroundMenuH := GetMenu(BackgroundMenu);
  1327.         InsertMenu(BackgroundMenuH, -1);
  1328.         PropagateMenuH := GetMenu(PropagateMenu);
  1329.         InsertMenu(PropagateMenuH, -1);
  1330.         ColorTablesMenuH := GetMenu(ColorTablesMenu);
  1331.         InsertMenu(ColorTablesMenuH, -1);
  1332.         AcquireMenuH := GetMenu(AcquireMenu);
  1333.         InsertMenu(AcquireMenuH, -1);
  1334.         ExportMenuH := GetMenu(ExportMenu);
  1335.         InsertMenu(ExportMenuH, -1);
  1336.         FilterMenuH := GetMenu(FilterMenu);
  1337.         InsertMenu(FilterMenuH, -1);
  1338.  
  1339.         TransferModeMenuH := GetMenu(TransferModeMenu);
  1340.         InsertMenu(TransferModeMenuH, -1);
  1341.  
  1342.         LineToolMenuH := GetMenu(LineToolMenu);
  1343.         InsertMenu(LineToolMenuH, -1);
  1344.  
  1345.         ImageMathOpsMenuH := GetMenu(ImageMathOpsMenu);
  1346.         InsertMenu(ImageMathOpsMenuH, -1);
  1347.  
  1348.         ImageListMenuH := GetMenu(ImageListMenu);
  1349.         InsertMenu(ImageListMenuH, -1);
  1350.  
  1351.         UnitsMenuH := GetMenu(UnitsMenu);
  1352.         InsertMenu(UnitsMenuH, -1);
  1353.  
  1354.         DrawMenuBar;
  1355.         AppendResMenu(AppleMenuH, 'DRVR');
  1356.         AppendResMenu(FontMenuH, 'FONT');
  1357.         NumFontItems := CountMItems(FontMenuH);
  1358.     end;
  1359.  
  1360.  
  1361.     function GetFolderDirID (parentFolderVRefNum: Integer; parentFolderDirID: LongInt; folderName: Str63; var folderDirID: LongInt): OSErr;
  1362.   {Given a folder's name, vRefNum, and parent dirID, find its dirID }
  1363.         var
  1364.             myCInfoPBRec: CInfoPBRec;
  1365.             retCode: OSErr;
  1366.     begin
  1367.         myCInfoPBRec.ioCompletion := nil;
  1368.         myCInfoPBRec.ioNamePtr := @folderName;
  1369.         myCinfoPBRec.ioVRefNum := parentFolderVRefNum;
  1370.         myCInfoPBRec.ioFDirIndex := 0; { use name, vRefNum, dirID }
  1371.         myCInfoPBRec.ioDrDirID := parentFolderDirID; { will be changed }
  1372.         retCode := PBGetCatInfoSync(@myCInfoPBRec); { IM IV-155 }
  1373.         if retCode = noErr then
  1374.             folderDirID := myCInfoPBRec.ioDrDirID;
  1375.         GetFolderDirID := retCode;
  1376.     end;
  1377.  
  1378.  
  1379.     procedure MyAppendMenu (menu: MenuHandle; item: integer; str: str255);
  1380.     begin
  1381.         AppendMenu(menu, ' ');
  1382.         SetMenuItemText(menu, item, str);
  1383.     end;
  1384.  
  1385.  
  1386.     procedure FindPlugIns;
  1387.         var
  1388.             err: OSErr;
  1389.             wdRefNum, index, SystemVRefNum: integer;
  1390.             name: Str255;
  1391.             ftype: OSType;
  1392.             PB: CInfoPBRec;
  1393.             ProcID, SystemDirID: LongInt;
  1394.             spec: FSSpec;
  1395.             pb2: WDPBRec;
  1396.             rCount, iFileRef: integer;
  1397.     begin
  1398.         if not System7 then
  1399.             exit(FindPlugIns);
  1400.         err := GetFolderDirID(LaunchVRefNum, LaunchDirID, 'Plug-Ins', PlugInsDirID);
  1401.         if err = NoErr then
  1402.             PlugInsVRefNum := LaunchVRefNum
  1403.         else if GetWDInfo(SystemRefNum, SystemVRefNum, SystemDirID, ProcID) = NoErr then
  1404.             if GetFolderDirID(SystemVRefNum, SystemDirID, 'Plug-Ins', PlugInsDirID) = NoErr then
  1405.                 PlugInsVRefNum := SystemVRefNum
  1406.             else
  1407.                 exit(FindPlugIns);
  1408.         err := OpenWD(PlugInsVRefNum, PlugInsDirID, 0, wdRefNum);
  1409.         if err <> NoErr then
  1410.             exit(FindPlugIns);
  1411.         index := 0;
  1412.         while true do
  1413.             begin
  1414.                 index := index + 1;
  1415.                 with PB do
  1416.                     begin
  1417.                         ioCompletion := nil;
  1418.                         ioNamePtr := @name;
  1419.                         ioVRefNum := wdRefNum;
  1420.                         ioDirID:=PlugInsDirID;
  1421.                         ioFDirIndex := index;
  1422.                         err := PBGetCatInfoSync(@PB); {ppc-bug}
  1423.                         if err = fnfErr then
  1424.                             leave;
  1425.                     end;
  1426.                 spec.vrefnum := PluginsVRefNum;
  1427.                 spec.parID := PlugInsDirID;
  1428.                 spec.name := name;
  1429.                 iFileRef := FSpOpenResFile(spec, fsCurPerm);
  1430.                 if iFileRef <> -1 then
  1431.                     begin
  1432.                         UseResFile(iFileRef);
  1433.                         rCount := Count1Resources('8BAM');
  1434.                         if rCount > 0 then
  1435.                             begin
  1436.                                 nAcqPlugIns := nAcqPlugIns + 1;
  1437.                                 if nAcqPlugIns = 1 then
  1438.                                     SetMenuItemText(AcquireMenuH, 1, name)
  1439.                                 else
  1440.                                     MyAppendMenu(AcquireMenuH, nAcqPlugIns, name);
  1441.                             end;
  1442.                         rCount := Count1Resources('8BEM');
  1443.                         if rCount > 0 then
  1444.                             begin
  1445.                                 nExportPlugIns := nExportPlugIns + 1;
  1446.                                 if nExportPlugIns = 1 then
  1447.                                     SetMenuItemText(ExportMenuH, 1, name)
  1448.                                 else
  1449.                                     MyAppendMenu(ExportMenuH, nExportPlugIns, name);
  1450.                             end;
  1451.                         rCount := Count1Resources('8BFM');
  1452.                         if rCount > 0 then
  1453.                             begin
  1454.                                 nFilterPlugIns := nFilterPlugIns + 1;
  1455.                                 if nFilterPlugIns = 1 then
  1456.                                     SetMenuItemText(FilterMenuH, 1, name)
  1457.                                 else
  1458.                                     MyAppendMenu(FilterMenuH, nFilterPlugIns, name);
  1459.                             end;
  1460.                         CloseResFile(iFileRef);
  1461.                     end;
  1462.                 ShowAnimatedWatch;
  1463.             end; {while}
  1464.         err := CloseWD(wdRefNum);
  1465.     end;
  1466.  
  1467.  
  1468.     procedure MakeGDevice;
  1469.   {Sets up an offscreen 8-bit graphics environment for use when the screen is not 8-bits.}
  1470.         var
  1471.             DeviceRect: Rect;
  1472.             h: CTabHandle;
  1473.             SaveDevice: GDHandle;
  1474.  
  1475.         procedure Abort;
  1476.         begin
  1477.             PutError('Error creating GDevice.');
  1478.             ExitToShell;
  1479.         end;
  1480.  
  1481.     begin
  1482.         SaveDevice := GetGDevice;
  1483.         SetRect(DeviceRect, 0, 0, 64, 64);
  1484.         h := GetCTable(AppleDefaultClut);
  1485.         if h = nil then
  1486.             abort;
  1487.         osGDevice := NewGDevice(0, -1);
  1488.         if osGDevice = nil then
  1489.             abort;
  1490.         with osGDevice^^ do
  1491.             begin
  1492.                 gdId := 0;
  1493.                 gdType := clutType;
  1494.                 gdResPref := 3;                                            { Color matching resolution. }
  1495.                 gdSearchProc := nil;
  1496.                 gdCompProc := nil;
  1497.                 gdFlags := $C401;                                            { 1100 0100 0000 0001 }
  1498.                 gdRect := DeviceRect;
  1499.                 with gdPMap^^ do
  1500.                     begin
  1501.                         baseAddr := nil;
  1502.                         bounds := DeviceRect;
  1503.                         rowBytes := 64 + $8000;
  1504.                         pixelSize := 8;
  1505.                         cmpCount := 1;
  1506.                         cmpSize := 8;
  1507.                         DisposeCTable(pmTable);
  1508.                         pmTable := h;
  1509.                     end;
  1510.             end;
  1511.         SetGDevice(SaveDevice);
  1512.     end;
  1513.  
  1514.  
  1515.     procedure LoadColorTable(PrefsStart, PrefsEnd: integer; PrefsInvert: boolean);
  1516.     {Load the pseudocolor LUT specified in preferences file.}
  1517.     begin
  1518.         with Info^ do begin
  1519.             if    LutMode = Pseudocolor then begin
  1520.                     SwitchColorTables(GetColorTableItem(ColorTable), false);
  1521.                     ColorStart := PrefsStart;
  1522.                     ColorEnd := PrefsEnd;
  1523.                     if PrefsInvert then
  1524.                         InvertPalette;
  1525.                     UpdateLut;
  1526.                 end;
  1527.             end;
  1528.     end;
  1529.  
  1530.  
  1531.     procedure Init;
  1532.         var
  1533.             i: integer;
  1534.             p: SyspPtr;
  1535.             mbhp: ^integer;
  1536.             str: str255;
  1537.             err: OSErr;
  1538.     begin
  1539.         SetApplLimit(ptr(ord4(GetApplLimit) - StackSize));
  1540.         MaxApplZone;
  1541.         for i := 1 to 20 do
  1542.             MoreMasters;
  1543.         InitGraf(@qd.thePort);
  1544.         InitFonts;
  1545.         InitWindows;
  1546.         InitCursor;
  1547.         TEInit;
  1548.         InitDialogs(@SysResume);
  1549.         CheckBits;
  1550.         ScreenPort := GrafPtr(NewPtr(SizeOf(GrafPort)));
  1551.         OpenPort(ScreenPort);
  1552.         NoInfo := @NoInfoRec;
  1553.         Info := NoInfo;
  1554.         InfoWindow := nil;
  1555.         with BlackRGB do
  1556.             begin
  1557.                 red := 0;
  1558.                 blue := 0;
  1559.                 green := 0;
  1560.             end;
  1561.         with WhiteRGB do
  1562.             begin
  1563.                 red := -1;
  1564.                 blue := -1;
  1565.                 green := -1;
  1566.             end;
  1567.  
  1568.         with NoInfo^ do
  1569.             begin
  1570.                 iVersion:=version;
  1571.                 nlines := 0;
  1572.                 PixelsPerLine := 0;
  1573.                 ImageSize := 0;
  1574.                 PixMapSize := 0;
  1575.                 PicBaseAddr := nil;
  1576.                 PicBaseHandle := nil;
  1577.                 osPort := nil;
  1578.                 RoiShowing := false;
  1579.                 RoiType := NoRoi;
  1580.                 RoiRect := SrcRect;
  1581.                 roiRgn := NewRgn;
  1582.                 title := 'NoInfo';
  1583.                 Magnification := 1.0;
  1584.                 PictureType := NullPicture;
  1585.                 wptr := nil;
  1586.                 Changes := false;
  1587.                 BytesPerRow := 0;
  1588.                 SetRect(SrcRect, 0, 0, 0, 0);
  1589.                 PicRect := SrcRect;
  1590.                 wrect := SrcRect;
  1591.                 initwrect := wrect;
  1592.                 savewrect := wrect;
  1593.                 SaveSrcRect := SrcRect;
  1594.                 SaveMagnification := magnification;
  1595.                 savehloc := 0;
  1596.                 savevloc := 0;
  1597.                 ScaleToFitWindow := false;
  1598.                 nColors := 256;
  1599.                 ColorStart := 0;
  1600.                 ColorEnd := 255;
  1601.                 SaveColorStart := 0;
  1602.                 SaveColorEnd := 255;
  1603.                 FillColor1 := BlackRGB;
  1604.                 FillColor2 := BlackRGB;
  1605.                 SaveFill1 := BlackRGB;
  1606.                 SaveFill2 := BlackRGB;
  1607.                 ColorTable := CustomTable;
  1608.                 LUTMode := GrayScale;
  1609.                 InvertedColorTable := false;
  1610.                 xUnit := 'pixel';
  1611.                 xScale := 0.0;
  1612.                 yScale := 0.0;
  1613.                 zScale := 1.0;
  1614.                 PixelAspectRatio := 1.0;
  1615.                 SpatiallyCalibrated := false;
  1616.                 UnitOfMeasure := '';
  1617.                 PicNum := 1;
  1618.                 PidNum := 0;
  1619.                 HeaderOffset := -1;
  1620.                 ImageDataOffset := -1;
  1621.                 ColorMapOffset := -1;
  1622.                 for i := 0 to 255 do
  1623.                     ctable[i].value := 0;
  1624.                 Fit := Uncalibrated;
  1625.                 ZeroClip := false;
  1626.                 nCoefficients := 0;
  1627.                 for i := 1 to 6 do
  1628.                     Coefficient[i] := 0.0;
  1629.                 BinaryPic := false;
  1630.                 WindowState := NormalWindow;
  1631.                 Revertable := false;
  1632.                 LX1 := -1.0;
  1633.                 LY1 := -1.0;
  1634.                 LX2 := -1.0;
  1635.                 LY2 := -1.0;
  1636.                 LAngle := 0.0;
  1637.                 IdentityFunction := false;
  1638.                 StackInfo := nil;
  1639.                 Thresholding := false;
  1640.                 fileVersion := 0;
  1641.                 vref := 0;
  1642.                 DataType := EightBits;
  1643.                 AbsoluteMin := 0;
  1644.                 AbsoluteMax := 0;
  1645.                 CurrentMin := 0;
  1646.                 CurrentMax := 0;
  1647.                 LittleEndian := false;
  1648.                 InvertedImage := false;
  1649.                 DataH := nil;
  1650.             end;
  1651.             
  1652.         MakeGDevice;
  1653.         LookForFrameGrabbers;
  1654.  
  1655.     {Default settings that can be changed by GetSettings.}
  1656.         ForegroundIndex := BlackIndex;
  1657.         BackgroundIndex := WhiteIndex;
  1658.         BrushWidth := 14;
  1659.         BrushHeight := 14;
  1660.         SprayCanDiameter := 32;
  1661.         SprayCanRadius := 16;
  1662.         SprayCanRadius2 := 256;
  1663.         CurrentFontID := Helvetica;
  1664.         CurrentStyle := []; {plain}
  1665.         CurrentSize := 12;
  1666.         TextJust := teJustLeft;
  1667.         TextBack := NoBack;
  1668.         nExtraColors := 0;
  1669.         InitExtraColors;
  1670.         InvertVideo := false;
  1671.         measurements := [AreaM, MeanM];
  1672.         InvertPlots := false;
  1673.         AutoscalePlots := true;
  1674.         LinePlot := true;
  1675.         DrawPlotLabels := true;
  1676.         FixedSizePlot := false;
  1677.         ProfilePlotWidth := 300;
  1678.         ProfilePlotHeight := 150;
  1679.         if FrameGrabber=ScionAG5 then begin
  1680.             FramesToAverage := 32;
  1681.             VideoRateAveraging:=true
  1682.         end else begin
  1683.             FramesToAverage := 16;
  1684.             VideoRateAveraging := false;
  1685.         end;
  1686.         NewPicWidth := 552;
  1687.         NewPicHeight := 436;
  1688.         BufferSize := DefaultBufferSize;
  1689.         ThresholdToForeground := true;
  1690.         NonThresholdToBackground := true;
  1691.         VideoChannel := 0;
  1692.         WhatToImport := ImportTIFF;
  1693.         ImportCustomWidth := 512;
  1694.         ImportCustomHeight := 512;
  1695.         ImportCustomOffset := 0;
  1696.         WandAdjustAreas := false;
  1697.         BinaryIterations := 1;
  1698.         ScaleArithmetic := true;
  1699.         InvertPixelValues := false;
  1700.         InvertYCoordinates := true;
  1701.         FieldWidth := 9;
  1702.         precision := 2;
  1703.         MinParticleSize := 1;
  1704.         MaxParticleSize := 999999;
  1705.         IgnoreParticlesTouchingEdge := false;
  1706.         LabelParticles := true;
  1707.         OutlineParticles := false;
  1708.         OscillatingMovies := false;
  1709.         MaxMeasurements := 256;
  1710.          ImportCustomDepth := EightBits;
  1711.         ImportSwapBytes := false;
  1712.         ImportCalibrate := true;
  1713.         ImportAutoScale := true;
  1714.         ShowHeadings := false;
  1715.         ProfilePlotMin := 0;
  1716.         ProfilePlotMax := 255;
  1717.         ImportMin := 0.0;
  1718.         ImportMax := 255.0;
  1719.         HighlightSaturatedPixels := false;
  1720.         BallRadius := 50;
  1721.         FasterBackgroundSubtraction := true;
  1722.         ScaleConvolutions := true;
  1723.         BinaryCount := 4;
  1724.         BinaryThreshold := BinaryCount * 255;
  1725.         HalftoneFrequency := 53;
  1726.         HalftoneAngle := 45;
  1727.         HalftoneDotFunction := true;
  1728.         SyncMode := NormalSync;
  1729.         SwitchLUTOnSuspend := false;
  1730.         ImportInvert := false;
  1731.         TextCreator := 'Imag';
  1732.         MathSubGain := 0.5;
  1733.         MathSubOffset := 128.0;
  1734.         MathGain := MathSubGain;
  1735.         MathOffset := MathSubOffset;
  1736.         fgScale := 1;
  1737.         UseBuiltinDigitizer := true;
  1738.         DigitizerMode := digitizeGrayscale;
  1739.         DigitizerStandard:= defaultStd;
  1740.         LUTFriendlyMode := false;
  1741.         {end default settings}
  1742.         
  1743.         GrayMapReady := false;
  1744.         GetSettings; {from 'Image Prefs' file}
  1745.  
  1746.         ExplicitPalette := NewPalette(256, nil, pmExplicit, 0);
  1747.         CScreenPort := CGrafPtr(NewPtr(SizeOf(CGrafPort)));
  1748.         OpenCPort(CScreenPort);
  1749.         SetPalette(WindowPtr(CScreenPort), ExplicitPalette, false);
  1750.         finished := false;
  1751.         FlushEvents(EveryEvent, 0);
  1752.         mbhp := pointer(MBarHeight);
  1753.         MenuBarHeight := mbhp^;
  1754.         SetRect(trect, tleft, ttop, tleft + twidth, ttop + theight);
  1755.         ToolWindow := NewCWindow(nil, trect, 'Tools', true, NoGrowDocProc, nil, false, 0);
  1756.         SetPalette(ToolWindow, ExplicitPalette, false);
  1757.         WindowPeek(ToolWindow)^.WindowKind := ToolKind;
  1758.         BringToFront(ToolWindow);
  1759.         ScreenWidth := qd.ScreenBits.Bounds.right;
  1760.         ScreenHeight := qd.ScreenBits.Bounds.bottom;
  1761.         SliceStart := 100;
  1762.         SliceEnd := 150;
  1763.         with SliceColor do
  1764.             begin
  1765.                 red := -1;
  1766.                 green := 0;
  1767.                 blue := 0;
  1768.             end;
  1769.         DensitySlicing := false;
  1770.         with NoInfo^ do
  1771.             if LutMode = grayscale then
  1772.                 ResetGrayMap
  1773.             else
  1774.                 LoadColorTable(ColorStart, ColorEnd, InvertedColorTable); {Use Image Prefs LUT}
  1775.         InitMenus;  {LUT must be setup before InitMenus}
  1776.         SetRect(gmrect, gmleft, gmtop, gmleft + gmwidth, gmtop + gmheight);
  1777.         SetRect(gmSlide1, gmrectleft, gmrectbottom + gmSlide1Offset, gmrectleft + gmSlideWidth, gmrectbottom + gmSlide1Offset + gmSlideHeight);
  1778.         gmSlide1i := gmSlide1;
  1779.         InsetRect(gmSlide1i, 1, 1);
  1780.         SetRect(gmSlide2, gmrectleft, gmrectbottom + gmSlide2Offset, gmrectleft + gmSlideWidth, gmrectbottom + gmSlide2Offset + gmSlideHeight);
  1781.         gmSlide2i := gmSlide2;
  1782.         InsetRect(gmSlide2i, 1, 1);
  1783.         SetRect(gmIcon1, gmIcon1left, gmrectbottom + gmIconOffset, gmIcon1left + gmIconWidth, gmrectbottom + gmIconOffset + gmIconHeight);
  1784.         SetRect(gmIcon2, gmIcon2left, gmrectbottom + gmIconOffset, gmIcon2left + gmIconWidth, gmrectbottom + gmIconOffset + gmIconHeight);
  1785.         MapWindow := NewWindow(nil, gmrect, 'Map', true, NoGrowDocProc, nil, false, 0);
  1786.         WindowPeek(MapWindow)^.WindowKind := MapKind;
  1787.         SetRect(MapRect1, gmRectLeft, gmRectTop, gmRectRight, gmRectBottom);
  1788.         MapRect2 := MapRect1;
  1789.         InsetRect(MapRect2, -2, -2);
  1790.         cheight := 256 + (2 + nExtraColors) * ExtraColorsHeight;
  1791.         SetRect(crect, cleft, ctop, cleft + cwidth, ctop + cheight);
  1792.         LUTWindow := NewCWindow(nil, crect, 'LUT', true, NoGrowDocProc, nil, false, 0);
  1793.         SetPalette(LUTWindow, ExplicitPalette, false);
  1794.         WindowPeek(LUTWindow)^.WindowKind := LUTKind;
  1795.         rleft := 2;
  1796.         if ScreenHeight > 480 then
  1797.             rtop := ScreenHeight - rheight - 5
  1798.         else
  1799.             rtop := 358;
  1800.         SetRect(trect, rleft, rtop, rleft + rwidth, rtop + rheight);
  1801.         InfoWindow := NewWindow(nil, trect, 'Info', true, NoGrowDocProc, nil, false, 0);
  1802.         BringToFront(InfoWindow);
  1803.         WindowPeek(InfoWindow)^.WindowKind := InfoKind;
  1804.         BuggyWatch := GetCursor(WatchCursor);
  1805.         InitTools;
  1806.         MakeCursors;
  1807.         nPics := 0;
  1808.         nextPid := -1;
  1809.         HistoWindow := nil;
  1810.         PlotWindow := nil;
  1811.         IsInsertionPoint := false;
  1812.         MaskRgn := NewRgn;
  1813.         PlotPICT := nil;
  1814.         CurrentUndoSize := 0;
  1815.         p := GetSyspPtr;
  1816.         BlinkTime := BitAnd($000F, p^.volclik) * 4;
  1817.         MakePatterns;
  1818.         PicLeftBase := twidth + cwidth + 10;
  1819.         PicTopBase := MenuBarHeight + 20;
  1820.         PicLeft := PicLeftBase;
  1821.         PicTop := PicTopBase;
  1822.         MouseState := NotInRoi;
  1823.         WhatsOnClip := NothingOnClip;
  1824.         OldScrapCount := GetScrapCount;
  1825.         ClipboardConverted := false;
  1826.         Digitizing := false;
  1827.         debugging := false;
  1828.         BlankFieldInfo := nil;
  1829.         PlotCount := 0;
  1830.         PlotAvg := 1;
  1831.         ActualPlotMin := 0.0;
  1832.         ActualPlotMax := 0.0;
  1833.         ClipTextInBuffer := false;
  1834.         TextBufP := TextBufPtr(NewPtr(SizeOf(TextBufType)));
  1835.         if TextBufP = nil then
  1836.             ExitToShell;
  1837.         MacrosP := MacrosPtr(NewPtr(SizeOf(MacrosRec)));
  1838.         if MacrosP = nil then
  1839.             ExitToShell;
  1840.         mCount := 0;
  1841.         mCount2 := 0;
  1842.         nPoints := 0;
  1843.         nLengths := 0;
  1844.         nAngles := 0;
  1845.         for i := 1 to MaxStandards do
  1846.             StandardValues[i] := BadReal;
  1847.         nStandards := 0;
  1848.         nKnownValues := 0;
  1849.         for i := 0 to 255 do
  1850.             cvalue[i] := i;
  1851.         WhatToUndo := NothingToUndo;
  1852.         WhatToCopy := NothingToCopy;
  1853.         PrintRecord := nil;
  1854.         printing := false;
  1855.         cr := chr(13);
  1856.         crStr:=chr(13);
  1857.         tab := chr(9);
  1858.         BackSpace := chr(8);
  1859.         eofChr := chr(4);
  1860.         measuring := false;
  1861.         UpdateFitEllipse;
  1862.         nListColumns := 0;
  1863.         if FrameGrabber=ScionAG5 then
  1864.             VideoRateAveraging:=true;
  1865.         RestoreUndoBuf := true;
  1866.         SelectionMode := NewSelection;
  1867.         RoiMovementState := Unconstrained;
  1868.         PasteControl := nil;
  1869.         PasteTransferMode := SrcCopy;
  1870.         ImportCustomSlices := 1;
  1871.         ImportAll := false;
  1872.         RoiNudged := false;
  1873.         OpPending := false;
  1874.         RedoSelection := false;
  1875.         WandAutoMeasure := false;
  1876.         OptionKeyWasDown := false;
  1877.         InfoMessage := '';
  1878.         SaveAsWhat := asTIFF;
  1879.         ExportAsWhat := asRaw;
  1880.         AnalyzingParticles := false;
  1881.         RedirectSampling := false;
  1882.         IncludeHoles := false;
  1883.         SaveAllState := NoSaveAll;
  1884.         ContinuousHistogram := false;
  1885.         DrawLabels(' ', '', '');
  1886.         HistogramSliceStart := 0;
  1887.         HistogramSliceEnd := 255;
  1888.         RoiUpdateTime := 0;
  1889.         MeasurementToRedo := 0;
  1890.         nMacros := 0;
  1891.         macro := false;
  1892.         KernelsRefNum := 0;
  1893.         DefaultRefNum := 0;
  1894.         MacrosRefNum := 0;
  1895.         LaunchVRefNum := 0;
  1896.         LaunchDirID := 0;
  1897.         PlugInsVRefNum := 0;
  1898.         PlugInsDirID := 0;
  1899.         DefaultFileName := '';
  1900.         rsHScale := 1.0;
  1901.         rsVScale := 1.0;
  1902.         rsAngle := 0.0;
  1903.         rsMethod := NearestNeighbor;
  1904.         rsCreateNewWindow := true;
  1905.         rsInteractive := false;
  1906.         DriverHalftoning := true;
  1907.         LivePasteMode := false;
  1908.         ShowCount := true;
  1909.         PasteControlLeft := ScreenWidth - pcwidth - 10;
  1910.         PasteControlTop := trunc(ScreenHeight * 0.2);
  1911.         MaxCoordinates := 10000;
  1912.         ResultsLeft := PicLeftBase;
  1913.         ResultsTop := 56;
  1914.         UnsavedResults := false;
  1915.         MajorLabel := 'Major';
  1916.         MinorLabel := 'Minor';
  1917.         User1Label := 'User 1';
  1918.         User2Label := 'User 2';
  1919.         MakingLOI := false;
  1920.         LOIType := Straight;
  1921.         MakingStack := false;
  1922.         FramesWanted := 20;
  1923.         DelayTicks := 0;
  1924.         CmdPeriodToStop := 'Type cmd-''.'' to stop.';
  1925.         CommandKey := chr(17);
  1926.         ClipboardColor := BlackRGB;
  1927.         InitAngle := 0;                                             {default is one full revolution of volume}
  1928.         TotalAngle := 360;
  1929.         AngleInc := 10;                                           {in ten-degree increments}
  1930.         TransparencyUpper := 254;                      {default has only value 255 transparent}
  1931.         TransparencyLower := 0;
  1932.         DepthCueSurf := 0;                                     {default has full depth-cueing for surface}
  1933.         DepthCueInt := 50;                                     {components and 50% depth-cueing elsewhere}
  1934.         Opacity := 0;
  1935.         SaveProjections := FALSE;                         {by default, do not save and close projections}
  1936.         AxisOfRotation := xAxis;
  1937.         MinProjSize := TRUE;                                {by default, make all windows just big enough}
  1938.         ProjectionMethod := NearestPoint;
  1939.         MeterWindow := nil;
  1940.         nCoordinates := 0;
  1941.         CoordinatesWidth := 0;
  1942.         CoordinatesHeight := 0;
  1943.         CoordinatesRoiType := NoRoi;
  1944.         SumFrames := false;
  1945.         ShowIntegratedValues := false;
  1946.         FixIntegrationScale := false;
  1947.         IntegrationMin := 0;
  1948.         IntegrationMax := 4096;
  1949.         ExternalTrigger := false;
  1950.         BlindMovieCapture := false;
  1951.         VideoControl := nil;
  1952.         DitherColor := true;
  1953.         RGBLut := CustomLUT;
  1954.         with Highlight1 do
  1955.             begin
  1956.                 red := -1;
  1957.                 green := 0;
  1958.                 blue := 0;
  1959.             end;
  1960.         with Highlight254 do
  1961.             begin
  1962.                 red := -1;
  1963.                 green := -1;
  1964.                 blue := 0;
  1965.             end;
  1966.         HighlightMode := false;
  1967.         LegalWithoutImage := [UpdateLutC, StartC, ShowResultsC, GetPicSizeC, PutMsgC, ExitC, CaptureC, MoveToC, BeepC, MakeNewC, SetPaletteC, SetBackC, GetRoiC, OpenC, ImportC, SetImportC, SetMinMaxC, SetCustomC, nPicsC, WaitC, SetSizeC, TriggerC, AverageFramesC, SaveStateC, RestoreStateC, SetCounterC, MakeStackC, ShowMsgC, SetUser1C, SetUser2C, SetOptionsC, RequiresC];
  1968.         LegalWithoutImage := LegalWithoutImage + [DisposeAllC, GetTimeC, SetForeC, SetBackC, GetStringC, OpenSerialC, GetSerialC, PutSerialC, SetCursorC, TickCountC, ConcatC, SetVideoC, StringToNumC, ChannelC, AcquireC, UndoSizeC, CallFilterC, PhotoModeC, DrawTextC, WriteC, WritelnC, NewTextWindowC, UserCodeC, SelectWindowC, BitAndC, BitOrC, WindowTitleC, ScaleConvolutionsC];
  1969.         LegalWithoutImage := LegalWithoutImage + [SaveC, SaveAsC, CloseC, DisposeC, PosC, DeleteC, LengthC, SetPrecisionC, SetExportC, ExportC, SetFontC, SetFontSizeC, SetTextC, GetC, MoveWindowC, GetFileInfoC, SelectToolC];
  1970.         TopOfStack := 0;
  1971.         SerialBufferP := nil;
  1972.         OpeningPlugInWindow := false;
  1973.         LG3DacA := 0;
  1974.         LG3DacB := 0;
  1975.         LG3DataOut := 0;
  1976.         nAcqPlugIns := 0;
  1977.         nExportPlugIns := 0;
  1978.         nFilterPlugIns := 0;
  1979.         LastAcqPlugIn := '';
  1980.         LastFilterPlugIn := '';
  1981.         LastExportPlugIn := '';
  1982.         TextInfo := nil;
  1983.         nTextWindows := 0;
  1984.         NewTitle := 'Untitled';
  1985.         CurrentWPtr := nil;
  1986.         CurrentKind := 0;
  1987.         SearchString := '';
  1988.         CurrentMathOp := SubMath;
  1989.         MathSrc1 := 1;
  1990.         MathSrc2 := 1;
  1991.         MathResult := 'Result';
  1992.         APReset := true;
  1993.         ShowPlot := true;
  1994.         FiducialMethod := OnScreen;
  1995.         ConfirmFidClicks := false;
  1996.         WatchIndex := 1;
  1997.         WireframeSurfacePlots := true;
  1998.         GrayscaleSurfacePlots := false;
  1999.         RankFilter := MedianRank;
  2000.         RankIterations := 1;
  2001.         TextScrollActionProc:=nil;
  2002.         AboutBoxFilterProc:=nil;    
  2003.         AboutBoxUserProc:=nil;
  2004.         ResultsScrollActionProc:=nil;
  2005.         ImageMathUserProc:=nil;
  2006.         SetScaleUserProc:=nil;
  2007.         OpenDHookProc:=nil;
  2008.         SaveAsDHookProc:=nil;
  2009.         ImportDHookProc:=nil;
  2010.         ExportDHookProc:=nil;
  2011.         BitInfoProc:=nil;
  2012.         GetPictDataProc:=nil;
  2013.         TestAbortProc:=nil;
  2014.         UpdateProgressProc:=nil;
  2015.         AG5LutMode := false;
  2016.         AG5GrabMode := GrabNormal;
  2017.         AG5BufferMode := Read0Lut1Grab0;
  2018.         IntegrateOnChip:=false;
  2019.         OpeningFinderFiles:=false;
  2020.         gNumberSlices:=true;
  2021.         gBorders:=true;
  2022.         RealImageMath:=false;
  2023.         DicomInitialized := false;
  2024.         ImportingDicom := false;
  2025.         err := HGetVol(nil, StartupSpec.vRefNum, StartupSpec.parID);
  2026.         OpeningRGB := false;
  2027.         PrecisionTiming := false;
  2028.         LG3BufferCapture := false;
  2029.         TimeStamp := false;
  2030.         SecondsPerFrame := 0.0;
  2031.         TriggerFirstFrameOnly := true;
  2032.         UseExistingStack := false;
  2033.         RealArithmetic := false;
  2034.         vdig := nil;
  2035.         GWorldLUT := nil;
  2036.         osGWorld := nil;
  2037.         if InvertPixelValues then
  2038.             InvertGrayLevels;
  2039.         MovieToolboxInitialized := false;
  2040. end;
  2041.  
  2042.  
  2043. end.